import { defineStore } from "pinia";
import UserAPI from "@/api/system/user.api.js";

export const useUserCacheStore = defineStore("userCache", {
  state: () => ({
    // 用户数据缓存
    users: new Map(), // key: userId, value: userInfo
    // 加载状态
    loading: false,
    loaded: false,
    // 分页信息
    currentPage: 1,
    pageSize: 100, // 每次加载更多用户
    total: 0,
    hasMore: true,
  }),

  getters: {
    /**
     * 根据用户ID获取用户信息
     */
    getUserById: (state) => (userId) => {
      if (!userId) return null;
      return state.users.get(String(userId)) || null;
    },

    /**
     * 获取所有用户列表
     */
    getAllUsers: (state) => {
      return Array.from(state.users.values());
    },
  },

  actions: {
    /**
     * 加载用户列表数据
     */
    async loadUsers(forceReload = false) {
      // 如果已经加载过且不是强制重新加载，直接返回
      if (this.loaded && !forceReload) {
        return;
      }

      // 如果正在加载，等待加载完成
      if (this.loading) {
        while (this.loading) {
          await new Promise((resolve) => setTimeout(resolve, 100));
        }
        return;
      }

      this.loading = true;
      try {
        // 重置状态
        if (forceReload) {
          this.users.clear();
          this.currentPage = 1;
          this.hasMore = true;
        }

        // 加载所有用户数据
        await this.loadAllUsers();
        this.loaded = true;
      } catch (error) {
        console.error("UserCacheStore: 加载用户列表失败", error);
        throw error;
      } finally {
        this.loading = false;
      }
    },

    /**
     * 分页加载所有用户数据
     */
    async loadAllUsers() {
      let currentPage = 1;
      let hasMore = true;

      while (hasMore) {
        try {
          const response = await UserAPI.getPage({
            pageNum: currentPage,
            pageSize: this.pageSize,
          });

          const { list, total } = response;

          // 缓存用户数据
          list.forEach((user) => {
            this.users.set(String(user.id), user);
          });

          this.total = total;

          // 检查是否还有更多数据
          hasMore = list.length === this.pageSize && this.users.size < total;
          currentPage++;

          // 避免无限循环
          if (currentPage > 100) {
            console.warn("UserCacheStore: 超过最大页数限制，停止加载");
            break;
          }
        } catch (error) {
          console.error(`UserCacheStore: 加载第${currentPage}页用户数据失败`, error);
          hasMore = false;
        }
      }
    },

    /**
     * 获取用户信息（自动加载）
     */
    async getUserInfo(userId) {
      if (!userId) return null;

      // 先从缓存中查找
      const cachedUser = this.getUserById(userId);
      if (cachedUser) {
        return cachedUser;
      }

      // 如果缓存中没有，尝试加载用户列表
      if (!this.loaded) {
        await this.loadUsers();
        // 再次从缓存中查找
        return this.getUserById(userId);
      }

      // 如果仍然没有找到，可能是新用户，尝试单独获取
      try {
        const userInfo = await UserAPI.getFormData(userId);
        if (userInfo) {
          this.users.set(String(userId), userInfo);
          return userInfo;
        }
      } catch (error) {
        console.error(`UserCacheStore: 获取用户${userId}信息失败`, error);
      }

      return null;
    },

    /**
     * 添加或更新用户信息
     */
    setUser(user) {
      if (user && user.id) {
        this.users.set(String(user.id), user);
      }
    },

    /**
     * 删除用户信息
     */
    removeUser(userId) {
      if (userId) {
        this.users.delete(String(userId));
      }
    },

    /**
     * 清除所有缓存
     */
    clearCache() {
      this.users.clear();
      this.loading = false;
      this.loaded = false;
      this.currentPage = 1;
      this.total = 0;
      this.hasMore = true;
    },

    /**
     * 刷新用户数据
     */
    async refreshUsers() {
      await this.loadUsers(true);
    },
  },
});
